package cn.ycc1.baseset.basics;

/**
 * 变量类型
 * @author ycc
 * @date 2025/3/3
 *
 * 变量类型默认值
 * The following table summarizes the default values for the above data types.
 *
 * Data Type	Default Value (for fields)
 * byte	0
 * short	0
 * int	0
 * long	0L
 * float	0.0f
 * double	0.0d
 * char	\u0000
 * String (or any object)	null
 * boolean	false
 *
 *  The eight primitive data types supported by the Java programming language are:
 *
 * byte: The byte data type is an 8-bit signed two's complement integer.
 * It has a minimum value of -128 and a maximum value of 127 (inclusive).
 * The byte data type can be useful for saving memory in large arrays,
 * where the memory savings actually matters. They can also be used in place of int where
 * their limits help to clarify your code; the fact that a variable's range is limited can serve as a form of documentation.
 *
 * short: The short data type is a 16-bit signed two's complement integer.
 * It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive).
 * As with byte, the same guidelines apply: you can use a short to save memory in large arrays,
 * in situations where the memory savings actually matters.
 *
 * int: By default, the int data type is a 32-bit signed two's complement integer,
 * which has a minimum value of -231 and a maximum value of 231-1.
 *
 * long: The long data type is a 64-bit two's complement integer.
 * The signed long has a minimum value of -263 and a maximum value of 263-1.
 *
 * float: The float data type is a single-precision 32-bit IEEE 754 floating point.
 * Its range of values is beyond the scope of this discussion, but is specified in the Floating-Point Types,
 * Formats, and Values section of the Java Language Specification. As with the recommendations for byte and short,
 * use a float (instead of double) if you need to save memory in large arrays of floating point numbers.
 * This data type should never be used for precise values, such as currency. For that,
 * you will need to use the java.math.BigDecimal class instead. Numbers and Strings covers BigDecimal
 * and other useful classes provided by the Java platform.
 *
 * double: The double data type is a double-precision 64-bit IEEE 754 floating point.
 * Its range of values is beyond the scope of this discussion,
 * but is specified in the Floating-Point Types, Formats, and Values section of the Java Language Specification.
 * For decimal values, this data type is generally the default choice. As mentioned above,
 * this data type should never be used for precise values, such as currency.
 *
 * boolean: The boolean data type has only two possible values: true and false.
 * Use this data type for simple flags that track true/false conditions.
 * This data type represents one bit of information, but its "size" isn't something that's precisely defined.
 *
 * char: The char data type is a single 16-bit Unicode character. It has a minimum value of \u0000 (or 0) and
 * a maximum value of \uffff (or 65,535 inclusive).
 */
public class Types {
    public static void main(String[] args) {
        int a = 10;
        double b = 20.5;
        String c = "Hello";
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        // The number 26, in decimal
        int decimalValue = 26;

        //  The number 26, in hexadecimal
        int hexadecimalValue = 0x1a;

        // The number 26, in binary
        int binaryValue = 0b11010;

        double d1 = 123.4;
        // same value as d1, but in scientific notation
        double d2 = 1.234e2;
        float f1  = 123.4f;

        long creditCardNumber = 1234_5678_9012_3456L;
        long socialSecurityNumber = 999_99_9999L;
        float pi =  3.14_15F;
        long hexBytes = 0xFF_EC_DE_5E;
        long hexWords = 0xCAFE_BABE;
        long maxLong = 0x7fff_ffff_ffff_ffffL;
        byte nybbles = 0b0010_0101;
        long bytes = 0b11010010_01101001_10010100_10010010;

    }
}
